// pages/my/my.js
// 导入用户管理工具类
const userManager = require('../../utils/userManager.js');
const { http } = require('../../utils/http.js');

const { getSelectedSubjectId } = require('../../utils/subject.js');
Page({

  /**
   * 页面的初始数据
   */
  data: {
    userInfo: null,
    isLoggedIn: false,
    loading: false,
    refreshing: false,
    subjectId:0,
    // 用户档案数据
    userProfile: null,
    memberDaysRemaining: 0,
    isVip: false,
    // 会员过期相关
    expiredDays: 0,
    isExpired: false,
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    // 页面加载时立即获取最新用户信息
    this.checkLoginStatus();
  },

  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady() {
   
  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {
    this.checkLoginStatus();
    // 如果已登录，加载用户档案
    if (this.data.isLoggedIn) {
      this.loadUserProfile();
    }
  },

  /**
   * 加载用户档案信息
   */
  loadUserProfile() {
    // 获取用户ID
    const userId = userManager.getUserId();
    console.log('=== my页面用户档案获取 ===');
    console.log('userManager.getUserId() 返回值:', userId);

    if (!userId) {
      console.log('用户ID为空，无法获取档案信息');
      return;
    }

    console.log('获取到用户ID:', userId);
    console.log('=== 开始调用用户档案接口 ===');

    // 调用用户档案接口
    const { http } = require('../../utils/http');

    // 使用正确的接口路径
    const apiUrl = `/points/profile/selectSysUserProfileByUserId?userId=${userId}`;
    console.log('调用接口:', apiUrl);

    http.get(apiUrl)
      .then(res => {
        console.log('获取用户档案完整响应:', res);

        // 检查响应结构
        if (res && res.code === 200 && res.data) {
          const profile = res.data;
          console.log('解析到的用户档案:', profile);

          // 检查并处理会员过期状态
          const processedProfile = this.checkAndHandleExpiredMembership(profile);

          // 提取需要的字段：memberType 和 memberExpire
          const memberType = processedProfile.memberType;
          const memberExpire = processedProfile.memberExpire;

          // 计算会员剩余天数
          const daysRemaining = this.calculateDaysRemaining(memberExpire);

          // 判断是否为会员
          const isVip = memberType === 'EXCLUSIVE' || memberType === 'GLOBAL';

          // 更新页面数据
          this.setData({
            userProfile: processedProfile,
            memberDaysRemaining: daysRemaining,
            isVip: isVip,
            expiredDays: processedProfile.expiredDays || 0,
            isExpired: processedProfile.isExpired || false
          });

          console.log('用户档案信息更新成功:', {
            memberType: memberType,
            memberExpire: memberExpire,
            daysRemaining: daysRemaining,
            isVip: isVip
          });
        } else {
          console.log('接口返回数据格式不正确或缺少data字段');
          this.setDefaultUserProfile();
        }
      })
      .catch(err => {
        console.error('获取用户档案失败:', err);
        this.setDefaultUserProfile();
      });
  },

  /**
   * 计算会员剩余天数
   */
  calculateDaysRemaining(expireDate) {
    if (!expireDate) {
      return 0;
    }

    try {
      const now = new Date();
      const expire = new Date(expireDate);
      const diffTime = expire.getTime() - now.getTime();
      const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24));

      return diffDays > 0 ? diffDays : 0;
    } catch (error) {
      console.error('计算剩余天数失败:', error);
      return 0;
    }
  },

  /**
   * 计算会员过期天数
   */
  calculateExpiredDays(expireDate) {
    if (!expireDate) {
      return 0;
    }

    try {
      const now = new Date();
      const expire = new Date(expireDate);
      const diffTime = now.getTime() - expire.getTime();
      const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24));

      return diffDays > 0 ? diffDays : 0;
    } catch (error) {
      console.error('计算过期天数失败:', error);
      return 0;
    }
  },

  /**
   * 检查并处理会员过期状态
   */
  checkAndHandleExpiredMembership(profile) {
    const memberType = profile.memberType;
    const memberExpire = profile.memberExpire;

    if (!memberExpire) {
      return profile; // 没有到期时间，直接返回
    }

    const expiredDays = this.calculateExpiredDays(memberExpire);
    const isExpired = expiredDays > 0;

    // 情况1: memberType=NONE 且有到期时间，显示已过期
    if (memberType === 'NONE' && memberExpire) {
      console.log(`会员已过期${expiredDays}天`);
      return {
        ...profile,
        memberType: 'NONE',
        expiredDays: expiredDays,
        isExpired: true
      };
    }

    // 情况2: memberType=GLOBAL或EXCLUSIVE，但已过期
    if ((memberType === 'GLOBAL' || memberType === 'EXCLUSIVE') && isExpired) {
      console.log(`会员已过期${expiredDays}天，需要更新为NONE`);
      // 调用接口更新会员状态为NONE
      this.updateMemberTypeToNone();

      return {
        ...profile,
        memberType: 'NONE',
        expiredDays: expiredDays,
        isExpired: true
      };
    }

    return profile;
  },

  /**
   * 更新会员类型为NONE
   */
  updateMemberTypeToNone() {
    const userId = userManager.getUserId();
    if (!userId) {
      console.log('用户ID为空，无法更新会员状态');
      return;
    }

    const { http } = require('../../utils/http');

    const requestData = {
      userId: userId,
      memberType: 'NONE',
      memberExpire: null
    };

    console.log('=== 开始调用会员状态更新接口 ===');
    console.log('请求数据:', requestData);

    http.put('/points/profile/updateMemberType', requestData)
      .then(res => {
        console.log('会员状态更新接口响应:', res);

        if (res && res.code === 200) {
          console.log('会员状态已更新为NONE');
        } else {
          console.error('会员状态更新失败:', res.msg || '未知错误');
        }
      })
      .catch(err => {
        console.error('会员状态更新接口调用失败:', err);
      });
  },

  /**
   * 设置默认用户档案信息
   */
  setDefaultUserProfile() {
    const defaultProfile = {
      memberType: null,
      memberExpire: null
    };

    this.setData({
      userProfile: defaultProfile,
      memberDaysRemaining: 0,
      isVip: false,
      expiredDays: 0,
      isExpired: false
    });

    console.log('设置默认用户档案信息:', defaultProfile);
    // 每次页面显示时都重新获取最新用户信息
    if (userManager.isLogin()) {
      this.updateUserInfoFromManager();
    }
  },

  /**
   * 检查登录状态
   */
  async checkLoginStatus() {
    const currentUser = userManager.getCurrentUser();
    
    if (currentUser) {
      // 已登录，先显示本地用户信息
      const userInfo = currentUser.userInfo || {};
      
      // 检查会员状态
      this.checkVipStatus(userInfo);
      
      this.setData({
        userInfo: userInfo,
        isLoggedIn: true
      });

      console.log('个人中心显示本地用户信息:', userInfo);

      // 使用userManager获取最新用户信息
      await this.updateUserInfoFromManager();
    } else {
      // 未登录
      this.setData({
        userInfo: null,
        isLoggedIn: false
      });
    }
  },

  /**
   * 使用userManager更新用户信息
   */
  async updateUserInfoFromManager() {
    if (!userManager.isLogin()) {
      return;
    }

    this.setData({ loading: true });

    try {
      // 使用userManager获取并更新用户信息
      const latestUserInfo = await userManager.getAndUpdateUserInfo();

      if (latestUserInfo) {
        // 更新页面数据
        this.setData({
          userInfo: latestUserInfo,
          isLoggedIn: true,
          loading: false
        });

        console.log('通过userManager获取到最新用户信息:', latestUserInfo);

        // 重新检查会员状态
        this.checkVipStatus(latestUserInfo);
      } else {
        this.setData({ loading: false });
        console.log('无法获取最新用户信息，保持当前状态');
      }
    } catch (error) {
      this.setData({ loading: false });
      console.error('通过userManager获取用户信息失败:', error);

      // 如果获取失败，显示提示但不影响页面显示
      wx.showToast({
        title: '获取用户信息失败',
        icon: 'none',
        duration: 2000
      });
    }
  },

  /**
   * 从后端获取用户信息（保留兼容性）
   */
  fetchUserInfoFromBackend() {
    // 现在推荐使用 updateUserInfoFromManager 方法
    this.updateUserInfoFromManager();
  },

  /**
   * 检查会员状态
   */
  checkVipStatus(userInfo) {
    // 这里可以根据实际的后端接口来获取会员状态
    // 目前先使用模拟数据
    const isVip = userInfo.isVip || false;
    const vipExpireDate = userInfo.vipExpireDate;
    
    // 如果用户是会员，检查是否即将到期
    if (isVip && vipExpireDate) {
      const now = new Date();
      const expireDate = new Date(vipExpireDate);
      const daysUntilExpire = Math.ceil((expireDate - now) / (1000 * 60 * 60 * 24));
      
      // 如果30天内到期，显示即将到期提示
      if (daysUntilExpire <= 30 && daysUntilExpire > 0) {
        this.setData({
          'userInfo.vipStatus': 'expiring',
          'userInfo.daysUntilExpire': daysUntilExpire
        });
      } else if (daysUntilExpire <= 0) {
        // 已过期
        this.setData({
          'userInfo.vipStatus': 'expired',
          'userInfo.isVip': false
        });
      }
    }
  },

  /**
   * 跳转到登录页面
   */
  goToLogin() {
    wx.showLoading({
      title: '正在跳转...'
    });
    setTimeout(() => {
      wx.hideLoading();
      wx.navigateTo({
        url: '/my/pages/Login/Login'
      });
    }, 300);
  },

  /**
   * 下拉刷新
   */
  async onPullDownRefresh() {
    this.setData({
      refreshing: true
    });

    try {
      // 重新检查登录状态
      await this.checkLoginStatus();

      // 如果已登录，强制刷新用户信息
      if (this.data.isLoggedIn) {
        await this.forceRefreshUserInfo();
      }
    } catch (error) {
      console.error('下拉刷新失败:', error);
    }

    setTimeout(() => {
      this.setData({
        refreshing: false
      });
      wx.stopPullDownRefresh();
    }, 1000);
  },

  /**
   * 用户信息点击事件
   */
  onUserInfoTap() {
    if (this.data.isLoggedIn) {
      wx.showToast({
        title: '用户信息',
        icon: 'none'
      });
    } else {
      this.goToLogin();
    }
  },

  /**
   * 编辑电话号码
   */
  editPhoneNumber() {
    if (!this.data.isLoggedIn) {
      wx.showToast({
        title: '请先登录',
        icon: 'none'
      });
      return;
    }

    wx.showModal({
      title: '修改手机号',
      content: '确定要修改手机号吗？',
      success: (res) => {
        if (res.confirm) {
          // 跳转到手机号修改页面或显示输入框
          this.showPhoneInputModal();
        }
      }
    });
  },

  /**
   * 显示手机号输入弹窗
   */
  showPhoneInputModal() {
    wx.showModal({
      title: '输入新手机号',
      editable: true,
      placeholderText: '请输入新的手机号',
      success: (res) => {
        if (res.confirm && res.content) {
          const newPhone = res.content.trim();

          // 验证手机号格式
          if (!/^1[3-9]\d{9}$/.test(newPhone)) {
            wx.showToast({
              title: '请输入有效的手机号',
              icon: 'none'
            });
            return;
          }

          // 调用后端接口更新手机号
          this.updatePhoneNumber(newPhone);
        }
      }
    });
  },

  /**
   * 更新手机号到后端
   */
  updatePhoneNumber(newPhone) {
    wx.showLoading({
      title: '更新中...',
      mask: true
    });

    const updateData = {
      phonenumber: newPhone
    };

    http.put('/system/user/profile', updateData)
      .then(res => {
        wx.hideLoading();

        if (res.code === 200) {
          wx.showToast({
            title: '手机号更新成功',
            icon: 'success'
          });

          // 更新本地用户信息
          this.setData({
            'userInfo.phonenumber': newPhone
          });

          // 更新本地存储
          const { setUserInfo } = require('../../utils/storageUtil.js');
          const currentUserInfo = this.data.userInfo;
          setUserInfo({
            ...currentUserInfo,
            phonenumber: newPhone
          });
        } else {
          wx.showToast({
            title: res.msg || '更新失败',
            icon: 'none'
          });
        }
      })
      .catch(err => {
        wx.hideLoading();
        console.error('更新手机号失败:', err);
        wx.showToast({
          title: '更新失败，请重试',
          icon: 'none'
        });
      });
  },

  /**
   * 跳转到消息中心
   */
  goToMessage() {
    wx.switchTab({
      url: '/pages/message/message',
    });
  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide() {
    console.log(this.data.subjectId);
  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload() {
    
  },



  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom() {

  },

  /**
   * 跳转到设置页面
   */
  goToSetting() {
    if (!userManager.isLogin()) {
      wx.showToast({
        title: '您还未登录',
        icon: 'none',
        duration: 1500
      });
    }
    
    // 已登录，跳转到设置页面
    wx.navigateTo({
      url: '/my/pages/Set/Set'
    });
  },
  /**
   * 跳转到练习记录页面
   */
  goToRecording() {
    wx.switchTab({
      url: '/pages/recording/recording'
    });
  },
  /**
   * 强制刷新用户信息
   */
  async forceRefreshUserInfo() {
    if (!userManager.isLogin()) {
      return;
    }

    try {
      // 使用userManager强制刷新用户信息
      const latestUserInfo = await userManager.forceRefreshUserInfo();

      if (latestUserInfo) {
        // 更新页面数据
        this.setData({
          userInfo: latestUserInfo,
          isLoggedIn: true
        });

        console.log('强制刷新获取到最新用户信息:', latestUserInfo);

        // 重新检查会员状态
        this.checkVipStatus(latestUserInfo);
      }
    } catch (error) {
      console.error('强制刷新用户信息失败:', error);
    }
  },

  /**
   * 刷新用户信息
   */
  async refreshUserInfo() {
    if (!userManager.isLogin()) {
      wx.showToast({
        title: '请先登录',
        icon: 'none'
      });
      return;
    }

    // 强制刷新用户信息
    await this.forceRefreshUserInfo();

    wx.showToast({
      title: '刷新成功',
      icon: 'success'
    });
    
    // 重新检查登录状态
    this.checkLoginStatus();
  },

  /**
   * 开通会员
   */
  activateMembership() {
    // 跳转到会员详情页面
    wx.navigateTo({
      url: '/index/pages/memberDetail/memberDetail',
      success: () => {
        console.log('跳转到会员详情页面成功');
      },
      fail: (err) => {
        console.error('跳转失败:', err);
        wx.showToast({
          title: '跳转失败',
          icon: 'none',
          duration: 2000
        });
      }
    });
  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage() {

  }
})